home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1997 January: Mac OS SDK / Dev.CD Jan 97 SDK2.toast / Development Kits (Disc 2) / OpenDoc / OpenDoc Development / Debugging Support / OpenDoc™ Source Code / Storage / Bento / EmbedCtr.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1996-08-28  |  17.1 KB  |  572 lines  |  [TEXT/MPS ]
  1. /*
  2.     File:        EmbedCtr.cpp
  3.  
  4.     Contains:    Implementation for ODEmbeddedContainer.
  5.  
  6.     Owned by:    Vincent Lo
  7.  
  8.     Copyright:    © 1993 - 1996 by Apple Computer, Inc., all rights reserved.
  9.  
  10.     Change History (most recent first):
  11.  
  12.          <7>     8/13/96    DM        1362809: make sure Close() can be called
  13.                                     again harmlessly even if an error occurs
  14.          <6>     7/23/96    DH        Bug #1371093: Fatal errors should be
  15.                                     allowed for embedded containers. Approved
  16.                                     by Bern.
  17.          <5>      6/6/96    jpa        T10020: Fixed uninitialized variable
  18.                                     (ODIText) warning.
  19.          <4>     5/24/96    jpa        1246074: SOM_CATCH --> SOM_TRY..SOM_ENDTRY
  20.          <3>     5/23/96    DH        1344338: Force quit of document when
  21.                                     dragging 'Bad' file or Container. Turned
  22.                                     off fatal Bento errors for Open and Create
  23.                                     container operations. Now Bento just throws
  24.                                     and the Container Manager can deal with the
  25.                                     error.
  26.  
  27.     To Do:
  28.         Eliminate shouldMerge in containerID.
  29.     In Progress:
  30.         
  31. */
  32.  
  33. #ifndef _QDFIXM_
  34. #include "QDFixM.h"
  35. #endif
  36.  
  37. #ifndef _PLFMDEF_
  38. #include "PlfmDef.h"
  39. #endif
  40.  
  41.  
  42. #define ODEmbeddedContainer_Class_Source
  43. #define VARIABLE_MACROS
  44. #include <EmbedCtr.xih>
  45.  
  46. #ifndef SOM_ODRefCntObject_xh
  47. #include <RefCtObj.xh>
  48. #endif
  49.  
  50. #ifndef SOM_ODStorageSystem_xh
  51. #include <ODStor.xh>
  52. #endif
  53.  
  54. #ifndef _SESSHDR_
  55. #include "SessHdr.h"        // for sessionRoutinesMetahandler
  56. #endif
  57.  
  58. #ifndef _EMBEDHDR_
  59. #include "EmbedHdr.h"
  60. #endif
  61.  
  62. #ifndef _TARGTHDR_
  63. #include "TargtHdr.h"
  64. #endif
  65.  
  66. #ifndef __CM_API__
  67. #include "CMAPI.h"
  68. #endif
  69.  
  70. #ifndef _EXCEPT_
  71. #include "Except.h"
  72. #endif
  73.  
  74. #ifndef _INDHDR_
  75. #include "IndHdr.h"
  76. #endif
  77.  
  78. #ifndef _ODNEW_
  79. #include "ODNew.h"
  80. #endif
  81.  
  82. #ifndef __STRING__
  83. #include <string.h>        // for strlen
  84. #endif
  85.  
  86. #ifndef _BENTOSUPPRESS_
  87. #include <BentoSuppress.h>
  88. #endif
  89.  
  90.  
  91. //==============================================================================
  92. // Constants
  93. //==============================================================================
  94. const ODType kODEmbeddedContainerTypeName = "EmbedHdr";
  95.  
  96. #if ODDebug
  97. // #define ODDebug_EmbedCtr 1
  98. #endif
  99.  
  100. #pragma segment EmbedCtr
  101.  
  102. //==============================================================================
  103. // ODEmbeddedContainer
  104. //==============================================================================
  105.  
  106. //------------------------------------------------------------------------------
  107. // ODEmbeddedContainer: GetName
  108. //------------------------------------------------------------------------------
  109.  
  110. SOM_Scope ODContainerName  SOMLINK ODEmbeddedContainerGetName(ODEmbeddedContainer *somSelf, Environment *ev)
  111. {
  112.     ODEmbeddedContainerData *somThis = ODEmbeddedContainerGetData(somSelf);
  113.     ODEmbeddedContainerMethodDebug("ODEmbeddedContainer","GetName");
  114.  
  115.     WARN("EmbeddedContainer does not have a name.");
  116.     
  117.     // The following two lines are used to pacify the compiler.
  118.     // They should never be executed.
  119.     ODIText    dummy;
  120.     InitIText(&dummy);
  121.     return dummy;
  122. }
  123.  
  124. //------------------------------------------------------------------------------
  125. // ODEmbeddedContainer: SetName
  126. //------------------------------------------------------------------------------
  127.  
  128. SOM_Scope void  SOMLINK ODEmbeddedContainerSetName(ODEmbeddedContainer *somSelf, Environment *ev,
  129.         ODContainerName* name)
  130. {
  131.     ODEmbeddedContainerData *somThis = ODEmbeddedContainerGetData(somSelf);
  132.     ODEmbeddedContainerMethodDebug("ODEmbeddedContainer","SetName");
  133.  
  134.     // This function is an no-op.
  135. }
  136.  
  137. //------------------------------------------------------------------------------
  138. // ODEmbeddedContainer: AcquireDocument
  139. //------------------------------------------------------------------------------
  140.  
  141. SOM_Scope ODDocument*  SOMLINK ODEmbeddedContainerAcquireDocument(ODEmbeddedContainer *somSelf, Environment *ev,
  142.         ODDocumentID id)
  143. {
  144.     ODEmbeddedContainerData *somThis = ODEmbeddedContainerGetData(somSelf);
  145.     ODEmbeddedContainerMethodDebug("ODEmbeddedContainer","AcquireDocument");
  146.  
  147. ODUnused(id);
  148.  
  149.     return kODNULL;
  150. }
  151.  
  152. //------------------------------------------------------------------------------
  153. // ODEmbeddedContainer: Release
  154. //------------------------------------------------------------------------------
  155.  
  156. SOM_Scope void  SOMLINK ODEmbeddedContainerRelease(ODEmbeddedContainer *somSelf, Environment *ev)
  157. {
  158.     ODEmbeddedContainerData *somThis = ODEmbeddedContainerGetData(somSelf);
  159.     ODEmbeddedContainerMethodDebug("ODEmbeddedContainer","Release");
  160.  
  161.     ODEmbeddedContainer_parent_ODBentoContainer_Release(somSelf, ev);
  162. }
  163.  
  164. //------------------------------------------------------------------------------
  165. // ODEmbeddedContainer: ~ODEmbeddedContainer
  166. //------------------------------------------------------------------------------
  167.  
  168. SOM_Scope void  SOMLINK ODEmbeddedContainersomUninit(ODEmbeddedContainer *somSelf)
  169. {
  170.     ODEmbeddedContainerData *somThis = ODEmbeddedContainerGetData(somSelf);
  171.     ODEmbeddedContainerMethodDebug("ODEmbeddedContainer","somUninit");
  172.  
  173. #ifdef DebugRefCount
  174.     printf("~ODEmbeddedContainer %x CMContainer %x\n", somSelf, _fContainer);
  175.     fflush(stdout);
  176. #endif
  177.  
  178.     Environment* ev = somGetGlobalEnvironment ();
  179.  
  180. //    if (_fCMContainer != kODNULL)
  181. //        somSelf->Close(ev);
  182.  
  183.     if (_fHandlers != kODNULL)
  184.         delete _fHandlers;
  185.  
  186. //    Theoretically, we should not delete the ID because they should be able to 
  187. //    be reused.
  188. //
  189. //    ODContainerID id = somSelf->GetID(ev);
  190. //    if (id != kXMPNULL)
  191. //        delete id;
  192.  
  193.     ODEmbeddedContainer_parent_ODBentoContainer_somUninit(somSelf);
  194. }
  195.  
  196. //------------------------------------------------------------------------------
  197. // ODEmbeddedContainer: InitContainer
  198. //------------------------------------------------------------------------------
  199.  
  200. SOM_Scope void  SOMLINK ODEmbeddedContainerInitContainer(ODEmbeddedContainer *somSelf, Environment *ev,
  201.         ODStorageSystem* storage,
  202.         ODContainerID* id)
  203. {
  204.     ODEmbeddedContainerData *somThis = ODEmbeddedContainerGetData(somSelf);
  205.     ODEmbeddedContainerMethodDebug("ODEmbeddedContainer","InitContainer");
  206.  
  207.     SOM_TRY
  208.  
  209.     /* Moved from somInit. SOM itself sets fields to zero
  210.     _fCMContainer = kODNULL;
  211.     _fHandlers = kODNULL;
  212.     _fTargetValue = kODNULL;
  213.     */
  214.     _fUseMode = kCMReading;
  215.     _fShouldMerge = kODTrue;
  216.  
  217.     ODEmbeddedContainer_parent_ODBentoContainer_InitContainer(somSelf, ev, storage, id);
  218.  
  219.     
  220.     ODByteArray ba = somSelf->GetID(ev);
  221.     ODEmbeddedContainerID    containerID = *((ODEmbeddedContainerID*) ba._buffer);
  222. //    _fShouldMerge = containerID.shouldMerge;
  223.     _fHandlers = new(somSelf->GetHeap(ev)) ODEmbeddedHandlers(somSelf->GetCMSession(ev),
  224.                                                                 containerID.cmValue);
  225.     _fHandlers->Initialize();
  226.  
  227.     ODDisposePtr(ba._buffer);
  228.  
  229.  
  230.     SOM_CATCH_ALL
  231.     SOM_ENDTRY
  232. }
  233.  
  234. //------------------------------------------------------------------------------
  235. // ODEmbeddedContainer: Create
  236. //------------------------------------------------------------------------------
  237.  
  238. SOM_Scope ODContainer*  SOMLINK ODEmbeddedContainerCreate(ODEmbeddedContainer *somSelf, Environment *ev)
  239. {
  240.     ODEmbeddedContainerData *somThis = ODEmbeddedContainerGetData(somSelf);
  241.     ODEmbeddedContainerMethodDebug("ODEmbeddedContainer","Create");
  242.  
  243.     SOM_TRY
  244.  
  245.     if (_fCMContainer == kODNULL) {
  246.  
  247.         CMSession cmSession = somSelf->GetCMSession(ev);
  248.         if (cmSession == kODNULL)
  249.             THROW(kODErrCannotCreateContainer);
  250.  
  251. //        ODType    prevObjectName = _fID->GetPrevObjectName();
  252.  
  253.         ODByteArray    ba = somSelf->GetID(ev);
  254.         CMValue cmValue = *((CMValue*) ba._buffer);
  255.         ODType prevObjectName = (ODType) CMGetValueRefCon(cmValue);
  256.         ODDisposePtr(ba._buffer);
  257.  
  258.         // Just to be safe, we are calling this even though we may have called this
  259.         // already for some other containers.
  260.         CMSetMetaHandler(cmSession,
  261.                         (CMGlobalName) CMTargetHandlersTypeName,
  262.                         targetContainerMetahandler);
  263.  
  264.         CMSetMetaHandler(cmSession, 
  265.                             kODIndirectValueGlobalName, 
  266.                             IndirectDynamicValueMetahandler);
  267.  
  268.         if (prevObjectName != kODNULL) {
  269. #if MergeContainersAvailable
  270.             CMValue             embeddedValue;
  271.             CMContainer            fileContainer;
  272.             CMObject            embeddedObject;
  273.             CMProperty            embeddedCntProp, targetObjectProp;
  274.             CMType                embeddedCntType;
  275.             CMObject            prevObject;
  276.             
  277.             _fCMContainer = CMOpenNewContainer(cmSession,
  278.                                         _fHandlers,
  279.                                         kODEmbeddedContainerTypeName,
  280.                                         (CMContainerUseMode) (kCMUpdateTarget+kCMMerging+kCMReuseFreeSpace),
  281.                                         kCMNextGeneration, kCMDefaultEndian,
  282.                                         prevObjectName);
  283.  
  284.             if (_fCMContainer == kODNULL)
  285.                 THROW(kODErrCannotCreateContainer);
  286.             ODVolatile(embeddedObject);
  287.             ODVolatile(embeddedCntProp);
  288.             ODVolatile(embeddedCntType);
  289.             TRY        
  290.                 ODSessionMustHaveCMAllocReserve(_fCMContainer);
  291.                 embeddedValue = _fHandlers->ReturnParentValueHandler();
  292.                 CMGetValueInfo(embeddedValue, &fileContainer, &embeddedObject, 
  293.                                 &embeddedCntProp, &embeddedCntType, kODNULL);
  294.                 targetObjectProp = CMRegisterProperty(fileContainer, prevObjectName);
  295.                 CMGetValueInfo(embeddedValue, &fileContainer, &embeddedObject, 
  296.                                 &embeddedCntProp, &embeddedCntType, NULL);
  297.                 prevObject = CMGetPrevObjectWithProperty(fileContainer, embeddedObject, embeddedCntProp);
  298.                 embeddedObject = CMGetPrevObjectWithProperty(fileContainer, embeddedObject, targetObjectProp);
  299.                 if (prevObject == embeddedObject)
  300.                     CMReleaseObject(prevObject);
  301.                 else {     /* we suspect this is garbage, check if we should delete it     */
  302.                     TRY /* if anything fails, garbage object is not deleted, big deal    */
  303.                         embeddedValue = CMUseValue(prevObject, embeddedCntProp, embeddedCntType);
  304.                         CMReleaseValue(embeddedValue);
  305.                         if (!CMContainsValidLabel(embeddedValue)) {
  306.                             CMReleaseObject(prevObject);
  307.                             CMDeleteObject(prevObject);
  308.                         }
  309.                         else
  310.                             CMReleaseObject(prevObject);
  311.                     CATCH_ALL
  312.                     ENDTRY
  313.                 }
  314.                 embeddedValue = CMUseValue(embeddedObject, embeddedCntProp, embeddedCntType);
  315.                 ODSessionRestoreCMAllocReserve(_fCMContainer);
  316.             CATCH_ALL
  317.                 embeddedValue = kODNULL;
  318.             ENDTRY
  319.             _fTargetValue = embeddedValue;
  320. #else
  321.             _fCMContainer = CMOpenNewContainer(cmSession,
  322.                                         _fHandlers,
  323.                                         kODEmbeddedContainerTypeName,
  324.                                         (CMContainerUseMode) (kCMUpdateTarget),
  325.                                         kCMNextGeneration, kCMDefaultEndian,
  326.                                         prevObjectName);
  327. #endif
  328.             _fUseMode = kCMUpdateTarget;
  329.             ODDisposePtr(prevObjectName);
  330.             CMSetValueRefCon(cmValue, kODNULL);
  331.         }
  332.         else {
  333.             _fCMContainer = CMOpenNewContainer(cmSession,
  334.                                         _fHandlers,
  335.                                         kODEmbeddedContainerTypeName,
  336.                                         (CMContainerUseMode) (kCMWriting),
  337.                                         kCMNextGeneration, kCMDefaultEndian);
  338.             _fUseMode = kCMWriting;
  339.         }
  340.         
  341.         if (_fCMContainer == kODNULL)
  342.             THROW(kODErrCannotCreateContainer);
  343.             
  344.     }
  345.  
  346.  
  347.     return somSelf;
  348.  
  349.     SOM_CATCH_ALL
  350.     SOM_ENDTRY
  351.     return (ODContainer*) kODNULL;
  352. }
  353.  
  354. //------------------------------------------------------------------------------
  355. // ODEmbeddedContainer: Open
  356. //------------------------------------------------------------------------------
  357.  
  358. SOM_Scope ODContainer*  SOMLINK ODEmbeddedContainerOpen(ODEmbeddedContainer *somSelf, Environment *ev)
  359. {
  360.     ODEmbeddedContainerData *somThis = ODEmbeddedContainerGetData(somSelf);
  361.     ODEmbeddedContainerMethodDebug("ODEmbeddedContainer","Open");
  362.  
  363.     SOM_TRY
  364.  
  365.     if (_fCMContainer == kODNULL) {
  366.  
  367.         CMSession cmSession = somSelf->GetCMSession(ev);
  368.         if (cmSession == kODNULL)
  369.             THROW(kODErrCannotOpenContainer);
  370.  
  371.         // Just to be safe, we are calling this even though we may have called this
  372.         // already for some other containers.
  373.         CMSetMetaHandler(cmSession,
  374.                         (CMGlobalName) CMTargetHandlersTypeName,
  375.                         targetContainerMetahandler);
  376.  
  377.         CMSetMetaHandler(cmSession, 
  378.                             kODIndirectValueGlobalName, 
  379.                             IndirectDynamicValueMetahandler);
  380.                 
  381.         _fCMContainer = CMOpenContainer(cmSession,
  382.                                         _fHandlers,
  383.                                     kODEmbeddedContainerTypeName,
  384.                                     (CMContainerUseMode)(kCMReading));
  385.  
  386.         ODSessionRestoreCMAllocReserve(_fCMContainer);
  387.         
  388.         if (_fCMContainer == kODNULL)
  389.             THROW(kODErrCannotOpenContainer);
  390.  
  391.         _fUseMode = kCMReading;
  392.     }
  393.         
  394.     return somSelf;
  395.  
  396.     SOM_CATCH_ALL
  397.     SOM_ENDTRY
  398.     return (ODContainer*) kODNULL;
  399. }
  400.  
  401. //------------------------------------------------------------------------------
  402. // ODEmbeddedContainer: Close
  403. //------------------------------------------------------------------------------
  404.  
  405. SOM_Scope ODContainer*  SOMLINK ODEmbeddedContainerClose(ODEmbeddedContainer *somSelf, Environment *ev)
  406. {
  407.     ODEmbeddedContainerData *somThis = ODEmbeddedContainerGetData(somSelf);
  408.     ODEmbeddedContainerMethodDebug("ODEmbeddedContainer","Close");
  409.     
  410.     SOM_TRY
  411.  
  412.     if (_fCMContainer != kODNULL) {
  413.     
  414.         ODSessionMustHaveCMAllocReserve(_fCMContainer);
  415. #if MergeContainersAvailable
  416.         if (_fShouldMerge && (_fUseMode != kCMReading)) {
  417. #ifdef ODDebug_EmbedCtr
  418. somPrintf("Closing EmbedCtr: Merge\n");
  419. #endif
  420.             CMMergeContainer(_fCMContainer, _fTargetValue);
  421.         }
  422.         else {
  423. #ifdef ODDebug_EmbedCtr
  424. somPrintf("Closing EmbedCtr: Close\n");
  425. #endif
  426.             CMCloseContainer(_fCMContainer);
  427.         }
  428.         if (_fTargetValue) {
  429.             CMReleaseValue(_fTargetValue);
  430.             _fTargetValue = kODNULL;
  431.         }
  432.  
  433. #else
  434.         CMCloseContainer(_fCMContainer);
  435. #endif
  436.         _fCMContainer = kODNULL;
  437.     }
  438.     
  439.     return somSelf;
  440.  
  441.     SOM_CATCH_ALL
  442.     
  443.     // Ensure that calling this function twice is harmless.
  444.     _fCMContainer = kODNULL;
  445.  
  446.     SOM_ENDTRY
  447.     return (ODContainer*) kODNULL;
  448. }
  449.  
  450. //------------------------------------------------------------------------------
  451. // ODEmbeddedContainer: Purge
  452. //------------------------------------------------------------------------------
  453.  
  454. SOM_Scope ODSize  SOMLINK ODEmbeddedContainerPurge(ODEmbeddedContainer *somSelf, Environment *ev,
  455.         ODSize size)
  456. {
  457.     ODEmbeddedContainerData *somThis = ODEmbeddedContainerGetData(somSelf);
  458.     ODEmbeddedContainerMethodDebug("ODEmbeddedContainer","Purge");
  459.  
  460.     ODULong    runningTotal = 0; ODVolatile( runningTotal );
  461.         
  462.     SOM_TRY
  463.          runningTotal = ODEmbeddedContainer_parent_ODBentoContainer_Purge(somSelf, ev, size);
  464.     SOM_CATCH_ALL
  465.         WARN("Error %ld trying to purge in CMDraftPurge",ErrorCode());
  466.         SetErrorCode(kODNoError);        // dh - Eat the exception; Purge should not 
  467.                                         // propagate it because clients function
  468.                                         // fine whether memory was purged or not.
  469.     SOM_ENDTRY
  470.  
  471.     return runningTotal;
  472. }
  473.  
  474. //------------------------------------------------------------------------------
  475. // ODEmbeddedContainer: ReleaseDocument
  476. //------------------------------------------------------------------------------
  477.  
  478. SOM_Scope ODContainer*  SOMLINK ODEmbeddedContainerReleaseDocument(ODEmbeddedContainer *somSelf, Environment *ev,
  479.         ODDocument* document)
  480. {
  481.     ODEmbeddedContainerData *somThis = ODEmbeddedContainerGetData(somSelf);
  482.     ODEmbeddedContainerMethodDebug("ODEmbeddedContainer","ReleaseDocument");
  483.  
  484. ODUnused(document);
  485.  
  486.     return somSelf;
  487. }
  488.  
  489. //------------------------------------------------------------------------------
  490. // ODEmbeddedContainer: Abort
  491. //------------------------------------------------------------------------------
  492.  
  493. SOM_Scope ODContainer*  SOMLINK ODEmbeddedContainerAbort(ODEmbeddedContainer *somSelf, Environment *ev)
  494. {
  495.     ODEmbeddedContainerData *somThis = ODEmbeddedContainerGetData(somSelf);
  496.     ODEmbeddedContainerMethodDebug("ODEmbeddedContainer","Abort");
  497.  
  498. //    SOM_CATCH return (ODContainer*) kODNULL;
  499.  
  500.     CMSize valueSize;
  501.  
  502.     if (_fCMContainer != kODNULL) {
  503.         if (_fUseMode != kCMReading) {
  504.             SOM_TRY
  505.                 ODSessionMustHaveCMAllocReserve(_fCMContainer);
  506.                 CMAbortContainer(_fCMContainer);
  507.                 
  508.                 // Trunc the value as Bento does not do it for us.
  509.                 ODByteArray    ba = somSelf->GetID(ev);
  510.                 CMValue value = *((CMValue*) ba._buffer);
  511.                 ODDisposePtr(ba._buffer);
  512.                 valueSize = CMGetValueSize(value);
  513.                 CMDeleteValueData(value, 0, valueSize);
  514.             SOM_CATCH_ALL
  515.             SOM_ENDTRY
  516.             _fCMContainer = kODNULL;
  517.         }
  518.     }
  519.     
  520.     return somSelf;
  521. }
  522.  
  523. //------------------------------------------------------------------------------
  524. // ODEmbeddedContainer: GetCMContainer
  525. //------------------------------------------------------------------------------
  526.  
  527. SOM_Scope CMContainer  SOMLINK ODEmbeddedContainerGetCMContainer(ODEmbeddedContainer *somSelf, Environment *ev)
  528. {
  529.     ODEmbeddedContainerData *somThis = ODEmbeddedContainerGetData(somSelf);
  530.     ODEmbeddedContainerMethodDebug("ODEmbeddedContainer","GetCMContainer");
  531.  
  532.     return _fCMContainer;
  533. }
  534.  
  535. //------------------------------------------------------------------------------
  536. // ODEmbeddedContainer: GetHandlers
  537. //------------------------------------------------------------------------------
  538.  
  539. SOM_Scope ODBentoHandlers*  SOMLINK ODEmbeddedContainerGetHandlers(ODEmbeddedContainer *somSelf, Environment *ev)
  540. {
  541.     ODEmbeddedContainerData *somThis = ODEmbeddedContainerGetData(somSelf);
  542.     ODEmbeddedContainerMethodDebug("ODEmbeddedContainer","GetHandlers");
  543.  
  544.     return _fHandlers;
  545. }
  546.  
  547. //------------------------------------------------------------------------------
  548. // ODEmbeddedContainer: GetUseMode
  549. //------------------------------------------------------------------------------
  550.  
  551. SOM_Scope CMContainerUseMode  SOMLINK ODEmbeddedContainerGetUseMode(ODEmbeddedContainer *somSelf, Environment *ev)
  552. {
  553.     ODEmbeddedContainerData *somThis = ODEmbeddedContainerGetData(somSelf);
  554.     ODEmbeddedContainerMethodDebug("ODEmbeddedContainer","GetHandlers");
  555.  
  556.     return _fUseMode;
  557. }
  558.  
  559. //------------------------------------------------------------------------------
  560. // ODEmbeddedContainer: SetMergeFlag
  561. //------------------------------------------------------------------------------
  562.  
  563. SOM_Scope void  SOMLINK ODEmbeddedContainerSetMergeFlag(ODEmbeddedContainer *somSelf, Environment *ev,
  564.         ODBoolean flag)
  565. {
  566.     ODEmbeddedContainerData *somThis = ODEmbeddedContainerGetData(somSelf);
  567.     ODEmbeddedContainerMethodDebug("ODEmbeddedContainer","SetMergeFlag");
  568.  
  569.     _fShouldMerge = flag;
  570. }
  571.  
  572.